const fs = require("fs");
const { cloneDeep } = require('lodash')
function 格式化输出模板代码(要分析的文件路径) {
    let 源代码片段 = 去除空数组(解析字符串为代码片段(fs.readFileSync(要分析的文件路径, 'utf8')))
    let 结果字符串 = ''
    let 全部片段 = 分解片段(源代码片段)
    function 分解片段(源代码片段) {
        let export内容 = []
        let 头部信息 = []
        let ReactFC内容 = []
        let 全局return之外 = []
        let return合并后内容
        let 全局return内容 = []
        let 函数组件名称 = []
        for (let [index, item] of cloneDeep(源代码片段).entries()) {

            if (item[0].trim().startsWith('export default')) {
                export内容.push(item)
            } else if (item[0].indexOf('React.FC') > -1) {
                ReactFC内容.push(item)
            } else {
                头部信息.push(item)
            }
        }


        for (let [, item] of ReactFC内容.entries()) {
            let 分块的代码 = 代码分块(item)
            函数组件名称.push(...分块的代码.头部信息)
            全局return之外.push(...分块的代码.return之外)
            全局return内容.push(...分块的代码.return内容)
        }
        return合并后内容 = return合并(全局return内容)
        function return合并(return内容) {
            let newItems = []
            for (let [, item] of return内容.entries()) {
                item.splice(item.length - 1, 1)
                item.splice(0, 1)
                newItems.push(item)
            }
            let returnArr = ['return <>']
            returnArr.push(...newItems)
            returnArr.push('</>')
            return returnArr
        }

        return {
            export内容,
            头部信息,
            全局return之外,
            return合并后内容,
            函数组件名称
        }

        function 代码分块(代码片段) {
            let 头部信息 = []
            let return之外 = []
            let return内容 = []
            for (let [index, item] of 代码片段.entries()) {
                if (item.indexOf('=> {') > -1) {
                    头部信息.push(代码片段.splice(0, index + 1))
                    break
                }
            }

            for (let [index, item] of 代码片段.reverse().entries()) {
                if (item.trim().startsWith('}') > -1) {
                    代码片段.splice(index, 1)
                    break
                }
            }

            代码片段.reverse()

            for (let [, item] of 解析字符串为代码片段(代码片段.join('\n')).entries()) {
                if (item[0].trim().startsWith('return')) {
                    return内容.push(item)
                } else {
                    return之外.push(item)
                }
            }

            return {
                return之外,
                return内容,
                头部信息
            }
        }
    }




    let 最终结果数组 = []
    最终结果数组 = 全部片段.头部信息.concat(全部片段.函数组件名称[0])
        .concat(全部片段.全局return之外).concat(全部片段.return合并后内容)
        .concat(['}']).concat(全部片段.export内容[0])

    flatten(最终结果数组).map((item, index) => {
        结果字符串 += item + '\n'
    })

    return 结果字符串

    function flatten(arr) {
        return arr.reduce((result, item) => {
            return result.concat(Array.isArray(item) ? flatten(item) : item);
        }, []);
    }

    function 解析字符串为代码片段(源代码字符串) {
        let 源代码片段 = []
        let 匹配键值对 = {
            '{': '}',
            '[': ']',
            '(': ')',
        }
        let 临时代码 = []
        let 括号数组 = []

        源代码字符串.split(/\r?\n/).forEach((line) => {

            临时代码.push(line)
            if (line) {
                for (let [key, value] of Object.entries(匹配键值对)) {// 遍历对象
                    let 转义的键 = '\\' + key.split('').join('\\')
                    let 转义的值 = '\\' + value.split('').join('\\')
                    let 匹配到的键 = line.match(eval("/" + 转义的键 + "/g"))
                    let 匹配到的值 = line.match(eval("/" + 转义的值 + "/g"))
                    if (匹配到的键) {
                        for (let [, item] of 匹配到的键.entries()) {
                            括号数组.push(item)
                        }
                    }
                    if (匹配到的值) {
                        for (let [, item] of 匹配到的值.entries()) {
                            括号数组.splice(0, 1)
                        }
                    }
                }
            }

            let 最后一个不是等于号 = (line.trim().substring(line.trim().length - 1, line.trim().length) !== '=')
            if (最后一个不是等于号 && 括号数组.length == 0) {
                源代码片段.push(临时代码)
                临时代码 = []
            }
        })
        return 源代码片段
    }




    function 去除空数组(原数组) {
        let 要被删除的数组 = []

        for (let [i, item] of 原数组.entries()) {
            if (item.length === 1 && item[0] === '' || item.length === 0) {
                要被删除的数组.push(i)
            }
        }
        要被删除的数组 = 要被删除的数组.reverse()
        for (let [, item] of 要被删除的数组.entries()) {
            原数组.splice(item, 1)
        }
        return 原数组
    }










}

fs.writeFile("./输出.tsx", 格式化输出模板代码('./输入.tsx'), function (err) {
    // 如果err为true，则文件写入失败，并返回失败信息
    if (err) {
        return console.log('文件写入失败！' + err.message)
    }
    // 若文件写入成功，将显示“文件写入成功”
    console.log('文件写入成功！')
})



